home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / m68k-pinsn.c < prev    next >
C/C++ Source or Header  |  1992-03-25  |  20KB  |  858 lines
  1. /* Print m68k instructions for GDB, the GNU debugger.
  2.    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #include <stdio.h>
  22.  
  23. #include "defs.h"
  24. #include "param.h"
  25. #include "symtab.h"
  26. #include "m68k-opcode.h"
  27.  
  28. /* 68k instructions are never longer than this many bytes.  */
  29. #define MAXLEN 22
  30.  
  31. /* Number of elements in the opcode table.  */
  32. #define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
  33.  
  34. extern char *reg_names[];
  35. char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
  36.              "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
  37.  
  38. static unsigned char *print_insn_arg ();
  39. static unsigned char *print_indexed ();
  40. static void print_base ();
  41. static int fetch_arg ();
  42.  
  43. #define NEXTBYTE(p)  (p += 2, ((char *)p)[-1])
  44.  
  45. #define NEXTWORD(p)  \
  46.   (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
  47.  
  48. #define NEXTLONG(p)  \
  49.   (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
  50.  
  51. #define NEXTSINGLE(p) \
  52.   (p += 4, *((float *)(p - 4)))
  53.  
  54. #define NEXTDOUBLE(p) \
  55.   (p += 8, *((double *)(p - 8)))
  56.  
  57. #define NEXTEXTEND(p) \
  58.   (p += 12, 0.0)    /* Need a function to convert from extended to double
  59.                precision... */
  60.  
  61. #define NEXTPACKED(p) \
  62.   (p += 12, 0.0)    /* Need a function to convert from packed to double
  63.                precision.   Actually, it's easier to print a
  64.                packed number than a double anyway, so maybe
  65.                there should be a special case to handle this... */
  66.  
  67. /* Print the m68k instruction at address MEMADDR in debugged memory,
  68.    on STREAM.  Returns length of the instruction, in bytes.  */
  69.  
  70. int
  71. print_insn (memaddr, stream)
  72.      CORE_ADDR memaddr;
  73.      FILE *stream;
  74. {
  75.   unsigned char buffer[MAXLEN];
  76.   register int i;
  77.   register unsigned char *p;
  78.   register char *d;
  79.   register int bestmask;
  80.   int best;
  81.  
  82.   read_memory (memaddr, buffer, MAXLEN);
  83.  
  84.   bestmask = 0;
  85.   best = -1;
  86.   for (i = 0; i < NOPCODES; i++)
  87.     {
  88.       register unsigned int opcode = m68k_opcodes[i].opcode;
  89.       register unsigned int match = m68k_opcodes[i].match;
  90.       if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
  91.       && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
  92.       && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
  93.       && ((0xff & buffer[3] & match) == (0xff & opcode)))
  94.     {
  95.       /* Don't use for printout the variants of divul and divsl
  96.          that have the same register number in two places.
  97.          The more general variants will match instead.  */
  98.       for (d = m68k_opcodes[i].args; *d; d += 2)
  99.         if (d[1] == 'D')
  100.           break;
  101.  
  102.       /* Don't use for printout the variants of most floating
  103.          point coprocessor instructions which use the same
  104.          register number in two places, as above. */
  105.       if (*d == 0)
  106.         for (d = m68k_opcodes[i].args; *d; d += 2)
  107.           if (d[1] == 't')
  108.         break;
  109.  
  110.       if (*d == 0 && match > bestmask)
  111.         {
  112.           best = i;
  113.           bestmask = match;
  114.         }
  115.     }
  116.     }
  117.  
  118.   /* Handle undefined instructions.  */
  119.   if (best < 0)
  120.     {
  121.       fprintf_filtered (stream, "0%o", (buffer[0] << 8) + buffer[1]);
  122.       return 2;
  123.     }
  124.  
  125.   fprintf_filtered (stream, "%s", m68k_opcodes[best].name);
  126.  
  127.   /* Point at first word of argument data,
  128.      and at descriptor for first argument.  */
  129.   p = buffer + 2;
  130.   
  131.   /* Why do this this way? -MelloN */
  132.   for (d = m68k_opcodes[best].args; *d; d += 2)
  133.     {
  134.       if (d[0] == '#')
  135.     {
  136.       if (d[1] == 'l' && p - buffer < 6)
  137.         p = buffer + 6;
  138.       else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
  139.         p = buffer + 4;
  140.     }
  141.       if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
  142.     p = buffer + 4;
  143.       if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
  144.     p = buffer + 6;
  145.       if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4)
  146.     p = buffer + 4;
  147.     }
  148.  
  149.   d = m68k_opcodes[best].args;
  150.  
  151.   if (*d)
  152.     fputc_filtered (' ', stream);
  153.  
  154.   while (*d)
  155.     {
  156.       p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream);
  157.       d += 2;
  158.       if (*d && *(d - 2) != 'I' && *d != 'k')
  159.     fprintf_filtered (stream, ",");
  160.     }
  161.   return p - buffer;
  162. }
  163.  
  164. static unsigned char *
  165. print_insn_arg (d, buffer, p, addr, stream)
  166.      char *d;
  167.      unsigned char *buffer;
  168.      register unsigned char *p;
  169.      CORE_ADDR addr;        /* PC for this arg to be relative to */
  170.      FILE *stream;
  171. {
  172.   register int val;
  173.   register int place = d[1];
  174.   int regno;
  175.   register char *regname;
  176.   register unsigned char *p1;
  177.   register double flval;
  178.   int flt_p;
  179.  
  180.   switch (*d)
  181.     {
  182.     case 'C':
  183.       fprintf_filtered (stream, "ccr");
  184.       break;
  185.  
  186.     case 'S':
  187.       fprintf_filtered (stream, "sr");
  188.       break;
  189.  
  190.     case 'U':
  191.       fprintf_filtered (stream, "usp");
  192.       break;
  193.  
  194.     case 'J':
  195.       {
  196.     static struct { char *name; int value; } names[]
  197.       = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
  198.          {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
  199.          {"msp", 0x803}, {"isp", 0x804}};
  200.  
  201.     val = fetch_arg (buffer, place, 12);
  202.     for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
  203.       if (names[regno].value == val)
  204.         {
  205.           fprintf_filtered (stream, names[regno].name);
  206.           break;
  207.         }
  208.     if (regno < 0)
  209.       fprintf_filtered (stream, "%d", val);
  210.       }
  211.       break;
  212.  
  213.     case 'Q':
  214.       val = fetch_arg (buffer, place, 3);
  215.       /* 0 means 8, except for the bkpt instruction... */
  216.       if (val == 0 && d[1] != 's')
  217.     val = 8;
  218.       fprintf_filtered (stream, "#%d", val);
  219.       break;
  220.  
  221.     case 'M':
  222.       val = fetch_arg (buffer, place, 8);
  223.       if (val & 0x80)
  224.     val = val - 0x100;
  225.       fprintf_filtered (stream, "#%d", val);
  226.       break;
  227.  
  228.     case 'T':
  229.       val = fetch_arg (buffer, place, 4);
  230.       fprintf_filtered (stream, "#%d", val);
  231.       break;
  232.  
  233.     case 'D':
  234.       fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
  235.       break;
  236.  
  237.     case 'A':
  238.       fprintf_filtered (stream, "%s",
  239.             reg_names[fetch_arg (buffer, place, 3) + 010]);
  240.       break;
  241.  
  242.     case 'R':
  243.       fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
  244.       break;
  245.  
  246.     case 'F':
  247.       fprintf_filtered (stream, "fp%d", fetch_arg (buffer, place, 3));
  248.       break;
  249.  
  250.     case 'O':
  251.       val = fetch_arg (buffer, place, 6);
  252.       if (val & 0x20)
  253.     fprintf_filtered (stream, "%s", reg_names [val & 7]);
  254.       else
  255.     fprintf_filtered (stream, "%d", val);
  256.       break;
  257.  
  258.     case '+':
  259.       fprintf_filtered (stream, "%s@+",
  260.             reg_names[fetch_arg (buffer, place, 3) + 8]);
  261.       break;
  262.  
  263.     case '-':
  264.       fprintf_filtered (stream, "%s@-",
  265.            reg_names[fetch_arg (buffer, place, 3) + 8]);
  266.       break;
  267.  
  268.     case 'k':
  269.       if (place == 'k')
  270.     fprintf_filtered (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
  271.       else if (place == 'C')
  272.     {
  273.       val = fetch_arg (buffer, place, 7);
  274.       if ( val > 63 )        /* This is a signed constant. */
  275.         val -= 128;
  276.       fprintf_filtered (stream, "{#%d}", val);
  277.     }
  278.       else
  279.     error ("Invalid arg format in opcode table: \"%c%c\".",
  280.            *d, place);
  281.       break;
  282.  
  283.     case '#':
  284.     case '^':
  285.       p1 = buffer + (*d == '#' ? 2 : 4);
  286.       if (place == 's')
  287.     val = fetch_arg (buffer, place, 4);
  288.       else if (place == 'C')
  289.     val = fetch_arg (buffer, place, 7);
  290.       else if (place == '8')
  291.     val = fetch_arg (buffer, place, 3);
  292.       else if (place == '3')
  293.     val = fetch_arg (buffer, place, 8);
  294.       else if (place == 'b')
  295.     val = NEXTBYTE (p1);
  296.       else if (place == 'w')
  297.     val = NEXTWORD (p1);
  298.       else if (place == 'l')
  299.